﻿Imports Microsoft.DirectX.Direct3D
Imports Microsoft.DirectX
Imports Commander_Wars.Spieletools
Public Class ObjektKarteneditor
#Region "Variablen"
    Public Shared PlatzeinesButtons As Byte = Hauptmenue.Feldbreite * 5 / 2
    Public Shared PlatzeinesSpielerButtons As Byte = Hauptmenue.Feldbreite * 2
    Public Shared Pfeilplatzgesamt As Integer = 48
    Public Const LuftLandschaften As Integer = 2
    Public Const LuftGebaeude As Integer = 4
    Public Const LuftSpezialGebaeude As Integer = 1
    Public Const AuswahlButtonsBreite As Integer = 40

    Dim BildIDStadtNeutral As Integer
    Dim BildIDStadt As Integer
    Dim Rand As Texture
    Public Randbreite As Integer

    Public EditorModusTexturen() As Texture = {}
    Public EditorGroessenTexturen() As Texture = {}

    Public CursorRechteck() As Rectangle = {}
    Public RechteckEditor() As Rectangle = {}
    Public MomenentanerSpieler As Integer = 0
    Public StartSpieler As Integer = 0
    Public LandschaftenEinheiteninderBreite As Integer = 0
    Public LandschafteninderHoehe As Integer = 0
    Public GebaeudeinderHoehe As Integer = 0
    Public GebaeudeinderBreite As Integer = 0

    Public StartIndexEinheiten As Integer = 0
    Public StartIndexLandschaften As Integer = 0
    Public StartIndexGebaeude As Integer = 0
    Public StartIndexSpezialgebaeude As Integer = 0

    Public AktuelleEinheit As Integer = 0
    Public AktuelleLandschaft As Integer = 0
    Public AktuelleGebaeude As Integer = 0
    Public AktuellesSpezialGebaeude As Integer = 0

    Dim Text As ObjektText
#End Region
#Region "Neu"
    Public Sub New()
        PlatzeinesButtons = Hauptmenue.Feldbreite * 5 / 2
        PlatzeinesSpielerButtons = Hauptmenue.Feldbreite * 2
        For I = 0 To Objektverwalter.AlleGebaeude.Length - 1
            If Objektverwalter.AlleGebaeude(I).GebaeudeID = "STADT" Then
                BildIDStadt = I
                Exit For
            End If
        Next
        BildIDStadtNeutral = BildIDStadt
        Array.Resize(RechteckEditor, 4)
        'Wir laden den Karteneditor je nach Bildschirm
        If DataSettings.Verhaeltnis = Hauptmenue.Breitbild Then
            Rand = Grafikengine.LoadTexture(DataSettings.Resourcenpfad + "Editor\Rand+1.6.bmp")
            'Zahlenwerte sind Daten aus dem Bild 
            Randbreite = 200 * DataSettings.Streckfaktor
            Hauptmenue.Rechteck.Width = DataSettings.BildschirmBreite - Randbreite
            RechteckEditor(0) = New Rectangle(DataSettings.BildschirmBreite - Randbreite + 7 * DataSettings.Streckfaktor, 7, 188 * DataSettings.Streckfaktor, 38)
            RechteckEditor(1) = New Rectangle(DataSettings.BildschirmBreite - Randbreite + 7 * DataSettings.Streckfaktor, 57, 188 * DataSettings.Streckfaktor, 38)
            RechteckEditor(2) = New Rectangle(DataSettings.BildschirmBreite - Randbreite + 7 * DataSettings.Streckfaktor, 106, 188 * DataSettings.Streckfaktor, 38)
            RechteckEditor(3) = New Rectangle(DataSettings.BildschirmBreite - Randbreite + 7 * DataSettings.Streckfaktor, 151 + 3 * ((DataSettings.BildschirmHoehe - 151) / 649), 188 * DataSettings.Streckfaktor, 637 * ((DataSettings.BildschirmHoehe - 151) / 649))

        Else
            Rand = Grafikengine.LoadTexture(DataSettings.Resourcenpfad + "Editor\Rand+1.3.bmp")
            'Zahlenwerte sind Daten aus dem Bild 
            Randbreite = 200 * DataSettings.Streckfaktor
            Hauptmenue.Rechteck.Width = DataSettings.BildschirmBreite - Randbreite
            RechteckEditor(0) = New Rectangle(DataSettings.BildschirmBreite - Randbreite + 7 * DataSettings.Streckfaktor, 7, 188 * DataSettings.Streckfaktor, 38)
            RechteckEditor(1) = New Rectangle(DataSettings.BildschirmBreite - Randbreite + 7 * DataSettings.Streckfaktor, 57, 188 * DataSettings.Streckfaktor, 38)
            RechteckEditor(2) = New Rectangle(DataSettings.BildschirmBreite - Randbreite + 7 * DataSettings.Streckfaktor, 106, 188 * DataSettings.Streckfaktor, 38)
            RechteckEditor(3) = New Rectangle(DataSettings.BildschirmBreite - Randbreite + 7 * DataSettings.Streckfaktor, 151 + 3 * ((DataSettings.BildschirmHoehe - 151) / 449), 188 * DataSettings.Streckfaktor, 437 * ((DataSettings.BildschirmHoehe - 151) / 449))

        End If
        'Hier wird festgelegt wie viele Bilder im Editor bereich angezeigt werden
        Dim Rest As Integer

        LandschaftenEinheiteninderBreite = Math.DivRem(RechteckEditor(3).Width, PlatzeinesButtons, Rest)
        LandschafteninderHoehe = Math.DivRem((RechteckEditor(3).Height - Pfeilplatzgesamt), PlatzeinesButtons, Rest)
        GebaeudeinderHoehe = Math.DivRem((RechteckEditor(3).Height - Pfeilplatzgesamt), PlatzeinesButtons, Rest)
        GebaeudeinderBreite = Math.DivRem(RechteckEditor(3).Width, Hauptmenue.Feldbreite * 2, Rest)



        'Hier werden allgemeine Dinge geladen
        'Zuerst Texturen


        ButtonTexturenladen()

        Text = New ObjektText(Nothing, 0, 0, New Color() {Color.Gray}, Schriftengine.Schriftarten.Arial, 11, FontStyle.Regular, , 4)

        'Jetzt Cursor
        CursorRechteckesetzen()
    End Sub
    Public Sub CursorRechteckesetzen()
        Dim Rest As Integer
        Array.Resize(CursorRechteck, 4)
        Dim Startrechteck As Rectangle
        If PlatzeinesSpielerButtons * Objektverwalter.Spielfeld.Spieler.Length > RechteckEditor(2).Width Then
            Dim AnzahldergemaltenSpieler As Integer = Math.DivRem((RechteckEditor(2).Width - Pfeilplatzgesamt), PlatzeinesSpielerButtons, Rest)
            If Hauptmenue.ZoomedIn Then
                Startrechteck = New Rectangle(RechteckEditor(2).X + Pfeilplatzgesamt / 2 + Rest / 2 + 1, 90, Hauptmenue.Feldbreite * 1.5 + 2, Hauptmenue.Feldbreite * 2)
            Else
                Startrechteck = New Rectangle(RechteckEditor(2).X + Pfeilplatzgesamt / 2 + Rest / 2 + 1, 108, Hauptmenue.Feldbreite * 1.5 + 2, Hauptmenue.Feldbreite * 2)
            End If
        Else
            If Hauptmenue.ZoomedIn Then
                Startrechteck = New Rectangle(2 + RechteckEditor(2).X + (RechteckEditor(2).Width - PlatzeinesSpielerButtons * Objektverwalter.Spielfeld.Spieler.Length) / 2, 90, Hauptmenue.Feldbreite * 1.5 + 2, Hauptmenue.Feldbreite * 2)
            Else
                Startrechteck = New Rectangle(2 + RechteckEditor(2).X + (RechteckEditor(2).Width - PlatzeinesSpielerButtons * Objektverwalter.Spielfeld.Spieler.Length) / 2, 108, Hauptmenue.Feldbreite * 1.5 + 2, Hauptmenue.Feldbreite * 2)
            End If
        End If
        CursorSpielersetzen(0, Startrechteck)
        Startrechteck = New Rectangle(RechteckEditor(0).X + RechteckEditor(0).Width / EditorModusTexturen.Length / 2 - 17, Hauptmenue.FeldbreiteKlein / 2, 34, 34)

        CursorRechteck(2) = Startrechteck
        Startrechteck = New Rectangle(RechteckEditor(1).X + RechteckEditor(1).Width / EditorModusTexturen.Length / 2 - 17, 57, 34, 34)
        CursorRechteck(3) = Startrechteck

        Startrechteck = New Rectangle(RechteckEditor(3).X + 4, RechteckEditor(3).Y + Pfeilplatzgesamt / 2 + 4, Hauptmenue.Feldbreite * 2, Hauptmenue.Feldbreite * 2)
        If Hauptmenue.ZoomedIn Then
            Startrechteck = New Rectangle(RechteckEditor(3).X + 1, RechteckEditor(3).Y + Pfeilplatzgesamt / 2 + 1, Hauptmenue.Feldbreite * 2 - 2, Hauptmenue.Feldbreite * 2 - 2)
        End If
        Math.DivRem((RechteckEditor(3).Height - Pfeilplatzgesamt), PlatzeinesButtons, Rest)
        Startrechteck.Y += Rest / 2
        Math.DivRem(RechteckEditor(3).Width, PlatzeinesButtons, Rest)
        Startrechteck.X += Rest / 2
        CursorRechteck(1) = Startrechteck

        EditorModus = EditorModi.Landschaften

        Dim M As ObjektKarteneditormenue = Objektverwalter.Menue
        M.KEModus = ObjektKarteneditormenue.KEModi.Landschaftplazieren
    End Sub
    Public Sub ButtonTexturenladen()
        Array.Resize(EditorModusTexturen, 4)
        EditorModusTexturen(0) = Grafikengine.LoadTexture(DataSettings.Resourcenpfad + "Editor\Buttons\EditorLandschaft.PNG")
        EditorModusTexturen(1) = Grafikengine.LoadTexture(DataSettings.Resourcenpfad + "Editor\Buttons\EditorEinheit.PNG")
        EditorModusTexturen(2) = Grafikengine.LoadTexture(DataSettings.Resourcenpfad + "Editor\Buttons\EditorGebaeude.PNG")
        EditorModusTexturen(3) = Grafikengine.LoadTexture(DataSettings.Resourcenpfad + "Editor\Buttons\EditorSpezialgebaeude.PNG")
        Array.Resize(EditorGroessenTexturen, 4)
        EditorGroessenTexturen(0) = Grafikengine.LoadTexture(DataSettings.Resourcenpfad + "Editor\Buttons\EditorAuswahlKlein.PNG")
        EditorGroessenTexturen(1) = Grafikengine.LoadTexture(DataSettings.Resourcenpfad + "Editor\Buttons\EditorAuswahlMittel.PNG")
        EditorGroessenTexturen(2) = Grafikengine.LoadTexture(DataSettings.Resourcenpfad + "Editor\Buttons\EditorAuswahlGross.PNG")
        EditorGroessenTexturen(3) = Grafikengine.LoadTexture(DataSettings.Resourcenpfad + "Editor\Buttons\Fuellen.PNG")
    End Sub

    Public Sub CursorSpielersetzen(ByVal Spieler As Integer, ByVal Rechteck As Rectangle)
        MomenentanerSpieler = Spieler
        CursorRechteck(0) = Rechteck
        Select Case EditorModus
            Case EditorModi.Landschaften
                CheckLandschaftenAuswahl(New Point(CursorRechteck(1).X + CursorRechteck(1).Width / 2, CursorRechteck(1).Y + CursorRechteck(1).Height / 2), Objektverwalter.Menue, False)
            Case EditorModi.Einheiten
                CheckEinheitenAuswahl(New Point(CursorRechteck(1).X + CursorRechteck(1).Width / 2, CursorRechteck(1).Y + CursorRechteck(1).Height / 2), Objektverwalter.Menue, False)
            Case EditorModi.Gebaeude
                CheckGebaeudeAuswahl(New Point(CursorRechteck(1).X + CursorRechteck(1).Width / 2, CursorRechteck(1).Y + CursorRechteck(1).Height / 2), Objektverwalter.Menue, False)
            Case EditorModi.Spezialgebaeude
                CheckSpezialGebaeudeAuswahl(New Point(CursorRechteck(1).X + CursorRechteck(1).Width / 2, CursorRechteck(1).Y + CursorRechteck(1).Height / 2), Objektverwalter.Menue, False)
        End Select

        If MomenentanerSpieler = 0 Then
            'Wir muessen noch etwas veraendern
            AktuelleEinheit = -1
            'Und das Rechteck muss wo anders hingesezt werden

        End If
    End Sub
    Public EditorModus As EditorModi = EditorModi.Landschaften
    Enum EditorModi
        Landschaften
        Einheiten
        Gebaeude
        Spezialgebaeude
    End Enum
    Public Plaziergroesse As PlazierGroessen = PlazierGroessen.Klein
    Enum PlazierGroessen
        Klein
        Mittel
        Gross
        Fuellen
    End Enum
#End Region
#Region "Klick"
    Public Function MouseDown(ByVal e As System.Windows.Forms.MouseEventArgs, ByVal Karteneditor As ObjektKarteneditormenue) As Boolean

        Dim Rueckgabe As Boolean = False
        If Karteneditor.KEModus <> ObjektKarteneditormenue.KEModi.Box Then
            Dim X As Integer = Hauptmenue.SpielfeldPunkt.X
            Dim Y As Integer = Hauptmenue.SpielfeldPunkt.Y
            Select Case e.Button
                Case MouseButtons.Left
                    If RechteckEditor(0).Contains(e.Location) = True Then
                        Return CheckEditorModus(e.Location, Karteneditor)
                    ElseIf RechteckEditor(1).Contains(e.Location) = True Then
                        Return CheckGoerssenauswahl(e.Location)
                    ElseIf RechteckEditor(2).Contains(e.Location) = True Then
                        Return SpielerauswahlcheckKlick(e.Location)
                    ElseIf RechteckEditor(3).Contains(e.Location) = True Then
                        If CheckPfeilRunterHoch(e.Location) Then
                            Return True
                        Else
                            Select Case EditorModus
                                Case ObjektKarteneditormenue.KEModi.Einheitabziehen

                                Case EditorModi.Einheiten
                                    Return CheckEinheitenAuswahl(e.Location, Karteneditor)
                                Case EditorModi.Gebaeude
                                    Return CheckGebaeudeAuswahl(e.Location, Karteneditor)
                                Case EditorModi.Spezialgebaeude
                                    CheckSpezialGebaeudeAuswahl(e.Location, Karteneditor)
                                Case EditorModi.Landschaften
                                    Return CheckLandschaftenAuswahl(e.Location, Karteneditor)
                            End Select
                        End If
                    End If
            End Select
        End If
        Return Rueckgabe
    End Function
    Public Function MouseUp(ByVal e As System.Windows.Forms.MouseEventArgs) As Boolean
        Select Case e.Button
            Case MouseButtons.Left

        End Select
        Return False
    End Function

    Public Function CheckEditorModus(ByVal p As System.Drawing.Point, ByVal Karteneditor As ObjektKarteneditormenue) As Boolean
        If Not Karteneditor.KEModus = ObjektKarteneditormenue.KEModi.Box Then
            Dim Rechteck As Rectangle = New Rectangle(RechteckEditor(0).X + RechteckEditor(0).Width / EditorModusTexturen.Length / 2 - 17, Hauptmenue.FeldbreiteKlein / 2, 34, 34)


            For I = 0 To EditorModusTexturen.Length - 1
                If Rechteck.Contains(p) Then
                    CursorRechteck(2) = Rechteck
                    Karteneditor.KEModus = I + 1

                    StartIndexEinheiten = 0
                    StartIndexLandschaften = 0
                    StartIndexGebaeude = 0
                    StartIndexSpezialgebaeude = 0

                    EditorModus = I
                    Select Case EditorModus
                        Case EditorModi.Einheiten
                            CheckEinheitenAuswahl(New Point(CursorRechteck(1).X + CursorRechteck(1).Width / 2, CursorRechteck(1).Y + CursorRechteck(1).Height / 2), Objektverwalter.Menue, False)
                        Case EditorModi.Gebaeude
                            CheckGebaeudeAuswahl(New Point(CursorRechteck(1).X + CursorRechteck(1).Width / 2, CursorRechteck(1).Y + CursorRechteck(1).Height / 2), Objektverwalter.Menue, False)
                        Case EditorModi.Landschaften
                            CheckLandschaftenAuswahl(New Point(CursorRechteck(1).X + CursorRechteck(1).Width / 2, CursorRechteck(1).Y + CursorRechteck(1).Height / 2), Objektverwalter.Menue, False)
                        Case EditorModi.Spezialgebaeude
                            CheckSpezialGebaeudeAuswahl(New Point(CursorRechteck(1).X + CursorRechteck(1).Width / 2, CursorRechteck(1).Y + CursorRechteck(1).Height / 2), Objektverwalter.Menue, False)
                    End Select
                    Return True
                Else
                    Rechteck.X += RechteckEditor(0).Width / EditorModusTexturen.Length
                End If
            Next
        Else
            Return False
        End If
        Return True
    End Function

    Private Function CheckGoerssenauswahl(ByVal p As System.Drawing.Point) As Boolean
        Dim Rechteck As Rectangle = New Rectangle(RechteckEditor(1).X + RechteckEditor(1).Width / EditorModusTexturen.Length / 2 - 17, 57, 34, 34)
        For I = 0 To EditorModusTexturen.Length - 1
            If Rechteck.Contains(p) Then
                CursorRechteck(3) = Rechteck
                Plaziergroesse = I
                Return True
            Else
                Rechteck.X += RechteckEditor(1).Width / EditorModusTexturen.Length
            End If
        Next
        Return True
    End Function

    Public Function SpielerauswahlcheckKlick(ByVal p As System.Drawing.Point) As Boolean
        Dim Startrechteck As Rectangle

        If PlatzeinesSpielerButtons * Objektverwalter.Spielfeld.Spieler.Length > RechteckEditor(2).Width Then
            Dim Rest As Integer
            Dim AnzahldergemaltenSpieler As Integer = Math.DivRem((RechteckEditor(2).Width - Pfeilplatzgesamt), PlatzeinesSpielerButtons, Rest)
            If Hauptmenue.ZoomedIn Then
                Startrechteck = New Rectangle(RechteckEditor(2).X + Pfeilplatzgesamt / 2 + Rest / 2 + 1, 90, Hauptmenue.Feldbreite * 1.5 + 2, Hauptmenue.Feldbreite * 2)
            Else
                Startrechteck = New Rectangle(RechteckEditor(2).X + Pfeilplatzgesamt / 2 + Rest / 2 + 1, 108, Hauptmenue.Feldbreite * 1.5 + 2, Hauptmenue.Feldbreite * 2)
            End If

            'Wir ueberpruefen ob man auf einen Pfeil geklickt hat
            Dim Rechteck As New Rectangle(RechteckEditor(2).X, RechteckEditor(2).Y + RechteckEditor(2).Height / 2 - 10, 20, 30)
            If Rechteck.Contains(p) Then
                StartSpieler -= 1
                CursorRechteck(0).X += Hauptmenue.Feldbreite * 2
                If StartSpieler < 0 Then
                    StartSpieler = 0
                    CursorRechteck(0).X -= Hauptmenue.Feldbreite * 2
                End If
                Spielercheck(AnzahldergemaltenSpieler)
            End If
            Rechteck = New Rectangle(RechteckEditor(2).X + RechteckEditor(2).Width - 20, RechteckEditor(2).Y + RechteckEditor(2).Height / 2 - 10, 20, 30)


            If Rechteck.Contains(p) Then
                If MomenentanerSpieler = StartSpieler Then
                    StartSpieler += 1
                Else
                    StartSpieler += 1
                    CursorRechteck(0).X -= Hauptmenue.Feldbreite * 2
                End If
                If StartSpieler + AnzahldergemaltenSpieler > Objektverwalter.Spielfeld.Spieler.Length - 1 Then
                    Dim Veraenderung As Integer = Objektverwalter.Spielfeld.Spieler.Length - AnzahldergemaltenSpieler
                    Veraenderung = StartSpieler - Veraenderung
                    If Not MomenentanerSpieler = StartSpieler - Veraenderung Then
                        CursorRechteck(0).X += Hauptmenue.Feldbreite * 2 * Veraenderung
                    End If
                    StartSpieler -= Veraenderung
                    If StartSpieler < 0 Then
                        Veraenderung = -StartSpieler
                        CursorRechteck(0).X -= Hauptmenue.Feldbreite * 2 * Veraenderung
                        StartSpieler = 0
                    End If
                End If
                Spielercheck(AnzahldergemaltenSpieler)
                Return True
            End If
            For I = 0 To AnzahldergemaltenSpieler - 1
                If Startrechteck.Contains(p) Then
                    CursorSpielersetzen(I + StartSpieler, Startrechteck)
                    Exit For
                End If
                Startrechteck.X += Hauptmenue.Feldbreite * 2
            Next
        Else
            If Hauptmenue.ZoomedIn Then
                Startrechteck = New Rectangle(2 + RechteckEditor(2).X + (RechteckEditor(2).Width - PlatzeinesSpielerButtons * Objektverwalter.Spielfeld.Spieler.Length) / 2, 90, Hauptmenue.Feldbreite * 1.5 + 2, Hauptmenue.Feldbreite * 2)
            Else
                Startrechteck = New Rectangle(2 + RechteckEditor(2).X + (RechteckEditor(2).Width - PlatzeinesSpielerButtons * Objektverwalter.Spielfeld.Spieler.Length) / 2, 108, Hauptmenue.Feldbreite * 1.5 + 2, Hauptmenue.Feldbreite * 2)
            End If
            For I = 0 To Objektverwalter.Spielfeld.Spieler.Length - 1
                If Startrechteck.Contains(p) Then
                    CursorSpielersetzen(I, Startrechteck)
                    Exit For
                End If
                Startrechteck.X += Hauptmenue.Feldbreite * 2
            Next
        End If
        Return True
    End Function

    Public Sub SpielerauswahlcheckKlick()
        Dim Startrechteck As Rectangle
        If Hauptmenue.ZoomedIn Then
            Startrechteck = New Rectangle(2 + RechteckEditor(2).X + (RechteckEditor(2).Width - PlatzeinesSpielerButtons * Objektverwalter.Spielfeld.Spieler.Length) / 2, 90, Hauptmenue.Feldbreite * 1.5 + 2, Hauptmenue.Feldbreite * 2)
        Else
            Startrechteck = New Rectangle(2 + RechteckEditor(2).X + (RechteckEditor(2).Width - PlatzeinesSpielerButtons * Objektverwalter.Spielfeld.Spieler.Length) / 2, 108, Hauptmenue.Feldbreite * 1.5 + 2, Hauptmenue.Feldbreite * 2)
        End If
        If PlatzeinesSpielerButtons * Objektverwalter.Spielfeld.Spieler.Length > RechteckEditor(2).Width Then
            Dim Rest As Integer
            Dim AnzahldergemaltenSpieler As Integer = Math.DivRem((RechteckEditor(2).Width - Pfeilplatzgesamt), PlatzeinesSpielerButtons, Rest)
            Startrechteck = New Rectangle(RechteckEditor(2).X + Pfeilplatzgesamt / 2 + Rest / 2, 108, Hauptmenue.Feldbreite * 1.5 + 2, Hauptmenue.Feldbreite * 2)
            'Wir ueberpruefen ob man auf einen Pfeil geklickt hat
        End If
        SpielerauswahlcheckKlick(New Point(Startrechteck.X + Startrechteck.Width / 2, Startrechteck.Y + Startrechteck.Height / 2))
    End Sub
    ''' <summary>
    ''' Checks if we have selected a new Unit to place!
    ''' </summary>
    ''' <param name="p"></param>
    ''' <param name="Karteneditor"></param>
    ''' <param name="Gefunden"></param>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Public Function CheckEinheitenAuswahl(ByVal p As Point, ByVal Karteneditor As ObjektKarteneditormenue, Optional ByVal Gefunden As Boolean = True) As Boolean
        Dim Startrechteck As New Rectangle(RechteckEditor(3).X + 4, RechteckEditor(3).Y + Pfeilplatzgesamt / 2 + 4, Hauptmenue.Feldbreite * 2, Hauptmenue.Feldbreite * 2)
        If Hauptmenue.ZoomedIn Then
            Startrechteck = New Rectangle(RechteckEditor(3).X + 1, RechteckEditor(3).Y + Pfeilplatzgesamt / 2 + 1, Hauptmenue.Feldbreite * 2 - 2, Hauptmenue.Feldbreite * 2 - 2)
        End If
        Dim Rest As Integer
        Math.DivRem((RechteckEditor(3).Height - Pfeilplatzgesamt), PlatzeinesButtons, Rest)
        Startrechteck.Y += Rest / 2
        Math.DivRem(RechteckEditor(3).Width, PlatzeinesButtons, Rest)
        Dim X2 As Integer = Rest / 2
        Startrechteck.X += Rest / 2
        For I = 0 To LandschafteninderHoehe - 1
            For I2 = 0 To LandschaftenEinheiteninderBreite - 1
                If Startrechteck.Contains(p) Then
                    If I * LandschaftenEinheiteninderBreite + I2 + StartIndexEinheiten < Objektverwalter.AlleEinheiten.Length Then
                        CursorRechteck(1) = Startrechteck
                        AktuelleEinheit = I * LandschaftenEinheiteninderBreite + I2 + StartIndexEinheiten
                        Karteneditor.KEModus = ObjektKarteneditormenue.KEModi.Einheitplazieren
                        Gefunden = True
                        GoTo Weiter
                    Else
                        GoTo Weiter
                    End If
                End If
                Startrechteck.X += PlatzeinesButtons
            Next
            Startrechteck.Y += PlatzeinesButtons
            Startrechteck.X = RechteckEditor(3).X + 4 + X2
        Next
Weiter:
        If Gefunden = False Then
            Startrechteck = New Rectangle(RechteckEditor(3).X + 4, RechteckEditor(3).Y + Pfeilplatzgesamt / 2 + 4, Hauptmenue.Feldbreite * 2, Hauptmenue.Feldbreite * 2)
            If Hauptmenue.ZoomedIn Then
                Startrechteck = New Rectangle(RechteckEditor(3).X + 1, RechteckEditor(3).Y + Pfeilplatzgesamt / 2 + 1, Hauptmenue.Feldbreite * 2 - 2, Hauptmenue.Feldbreite * 2 - 2)
            End If
            Math.DivRem((RechteckEditor(3).Height - Pfeilplatzgesamt), PlatzeinesButtons, Rest)
            Startrechteck.Y += Rest / 2
            Math.DivRem(RechteckEditor(3).Width, PlatzeinesButtons, Rest)
            Startrechteck.X += Rest / 2
            CursorRechteck(1) = Startrechteck
            Karteneditor.KEModus = ObjektKarteneditormenue.KEModi.Einheitplazieren
            AktuelleEinheit = 0
        End If
        If MomenentanerSpieler = 0 Then
            CursorRechteck(1) = New Rectangle(-20, -20, 0, 0)
            Karteneditor.KEModus = ObjektKarteneditormenue.KEModi.Nichts
        End If
        Return True
    End Function
    ''' <summary>
    ''' Returns over which Unit the Cursor currently is.
    ''' </summary>
    ''' <param name="p"></param>
    ''' <param name="Karteneditor"></param>
    ''' <param name="Gefunden"></param>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Public Function GetEinheitenAuswahl(ByVal p As Point, ByVal Karteneditor As ObjektKarteneditormenue, Optional ByVal Gefunden As Boolean = True) As Integer
        Dim Startrechteck As New Rectangle(RechteckEditor(3).X + 4, RechteckEditor(3).Y + Pfeilplatzgesamt / 2 + 4, Hauptmenue.Feldbreite * 2, Hauptmenue.Feldbreite * 2)
        If Hauptmenue.ZoomedIn Then
            Startrechteck = New Rectangle(RechteckEditor(3).X + 1, RechteckEditor(3).Y + Pfeilplatzgesamt / 2 + 1, Hauptmenue.Feldbreite * 2 - 2, Hauptmenue.Feldbreite * 2 - 2)
        End If
        Dim Rest As Integer
        Math.DivRem((RechteckEditor(3).Height - Pfeilplatzgesamt), PlatzeinesButtons, Rest)
        Startrechteck.Y += Rest / 2
        Math.DivRem(RechteckEditor(3).Width, PlatzeinesButtons, Rest)
        Dim X2 As Integer = Rest / 2
        Startrechteck.X += Rest / 2
        For I = 0 To LandschafteninderHoehe - 1
            For I2 = 0 To LandschaftenEinheiteninderBreite - 1
                If Startrechteck.Contains(p) Then
                    If I * LandschaftenEinheiteninderBreite + I2 + StartIndexEinheiten < Objektverwalter.AlleEinheiten.Length Then
                        Return I * LandschaftenEinheiteninderBreite + I2 + StartIndexEinheiten
                    End If
                End If
                Startrechteck.X += PlatzeinesButtons
            Next
            Startrechteck.Y += PlatzeinesButtons
            Startrechteck.X = RechteckEditor(3).X + 4 + X2
        Next
        Return -1
    End Function
    ''' <summary>
    ''' Checks if we have selected a new Terrain to place!
    ''' </summary>
    ''' <param name="p"></param>
    ''' <param name="Karteneditor"></param>
    ''' <param name="Gefunden"></param>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Public Function CheckLandschaftenAuswahl(ByVal p As Point, ByVal Karteneditor As ObjektKarteneditormenue, Optional ByVal Gefunden As Boolean = True) As Boolean
        'Wir ueberpruefen ob man auf einen Pfeil geklickt hat
        Dim Startrechteck As New Rectangle(RechteckEditor(3).X + 4, RechteckEditor(3).Y + Pfeilplatzgesamt / 2 + 4, Hauptmenue.Feldbreite * 2, Hauptmenue.Feldbreite * 2)
        If Hauptmenue.ZoomedIn Then
            Startrechteck = New Rectangle(RechteckEditor(3).X + 1, RechteckEditor(3).Y + Pfeilplatzgesamt / 2 + 1, Hauptmenue.Feldbreite * 2 - 2, Hauptmenue.Feldbreite * 2 - 2)
        End If
        Dim Rest As Integer
        Math.DivRem((RechteckEditor(3).Height - Pfeilplatzgesamt), PlatzeinesButtons, Rest)
        Startrechteck.Y += Rest / 2
        Math.DivRem(RechteckEditor(3).Width, PlatzeinesButtons, Rest)
        Dim X2 As Integer = Rest / 2
        Startrechteck.X += Rest / 2
        Dim LuftStart As Integer = 0
        If Objektverwalter.Spielfeld.MomentaneSchlacht = ObjektSpielfeld.Luftschlacht Then LuftStart = Objektverwalter.LandschaftenBilder.Length - LuftLandschaften
        Dim LuftEnde As Integer = Objektverwalter.LandschaftenBilder.Length
        If Objektverwalter.Spielfeld.MomentaneSchlacht = ObjektSpielfeld.Bodenschlacht Then LuftEnde -= LuftLandschaften
        For I = 0 To LandschafteninderHoehe - 1
            For I2 = 0 To LandschaftenEinheiteninderBreite - 1
                If Startrechteck.Contains(p) Then
                    If I * LandschaftenEinheiteninderBreite + I2 + StartIndexLandschaften + LuftStart < LuftEnde Then
                        CursorRechteck(1) = Startrechteck
                        AktuelleLandschaft = I * LandschaftenEinheiteninderBreite + I2 + StartIndexLandschaften + LuftStart
                        Karteneditor.KEModus = ObjektKarteneditormenue.KEModi.Landschaftplazieren
                        GoTo Weiter
                    Else
                        Gefunden = False
                        GoTo Weiter
                    End If
                End If
                Startrechteck.X += PlatzeinesButtons
            Next
            Startrechteck.Y += PlatzeinesButtons
            Startrechteck.X = RechteckEditor(3).X + 4 + X2
        Next
Weiter:
        If Gefunden = False Then
            Startrechteck = New Rectangle(RechteckEditor(3).X + 4, RechteckEditor(3).Y + Pfeilplatzgesamt / 2 + 4, Hauptmenue.Feldbreite * 2, Hauptmenue.Feldbreite * 2)
            If Hauptmenue.ZoomedIn Then
                Startrechteck = New Rectangle(RechteckEditor(3).X + 1, RechteckEditor(3).Y + Pfeilplatzgesamt / 2 + 1, Hauptmenue.Feldbreite * 2 - 2, Hauptmenue.Feldbreite * 2 - 2)
            End If
            Math.DivRem((RechteckEditor(3).Height - Pfeilplatzgesamt), PlatzeinesButtons, Rest)
            Startrechteck.Y += Rest / 2
            Math.DivRem(RechteckEditor(3).Width, PlatzeinesButtons, Rest)
            Startrechteck.X += Rest / 2
            CursorRechteck(1) = Startrechteck
            Karteneditor.KEModus = ObjektKarteneditormenue.KEModi.Landschaftplazieren
            AktuelleLandschaft = StartIndexLandschaften + LuftStart
        End If
        Return True
    End Function
    ''' <summary>
    ''' Returns over which Terrain the Cursor currently is.
    ''' </summary>
    ''' <param name="p"></param>
    ''' <param name="Karteneditor"></param>
    ''' <param name="Gefunden"></param>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Public Function GetLandschaftenAuswahl(ByVal p As Point, ByVal Karteneditor As ObjektKarteneditormenue, Optional ByVal Gefunden As Boolean = True) As Integer
        'Wir ueberpruefen ob man auf einen Pfeil geklickt hat
        Dim Startrechteck As New Rectangle(RechteckEditor(3).X + 4, RechteckEditor(3).Y + Pfeilplatzgesamt / 2 + 4, Hauptmenue.Feldbreite * 2, Hauptmenue.Feldbreite * 2)
        If Hauptmenue.ZoomedIn Then
            Startrechteck = New Rectangle(RechteckEditor(3).X + 1, RechteckEditor(3).Y + Pfeilplatzgesamt / 2 + 1, Hauptmenue.Feldbreite * 2 - 2, Hauptmenue.Feldbreite * 2 - 2)
        End If
        Dim Rest As Integer
        Math.DivRem((RechteckEditor(3).Height - Pfeilplatzgesamt), PlatzeinesButtons, Rest)
        Startrechteck.Y += Rest / 2
        Math.DivRem(RechteckEditor(3).Width, PlatzeinesButtons, Rest)
        Dim X2 As Integer = Rest / 2
        Startrechteck.X += Rest / 2
        Dim LuftStart As Integer = 0
        If Objektverwalter.Spielfeld.MomentaneSchlacht = ObjektSpielfeld.Luftschlacht Then LuftStart = Objektverwalter.LandschaftenBilder.Length - LuftLandschaften
        Dim LuftEnde As Integer = Objektverwalter.LandschaftenBilder.Length
        If Objektverwalter.Spielfeld.MomentaneSchlacht = ObjektSpielfeld.Bodenschlacht Then LuftEnde -= LuftLandschaften
        For I = 0 To LandschafteninderHoehe - 1
            For I2 = 0 To LandschaftenEinheiteninderBreite - 1
                If Startrechteck.Contains(p) Then
                    If I * LandschaftenEinheiteninderBreite + I2 + StartIndexLandschaften + LuftStart < LuftEnde Then
                        Return I * LandschaftenEinheiteninderBreite + I2 + StartIndexLandschaften + LuftStart
                    End If
                End If
                Startrechteck.X += PlatzeinesButtons
            Next
            Startrechteck.Y += PlatzeinesButtons
            Startrechteck.X = RechteckEditor(3).X + 4 + X2
        Next
        Return -1
    End Function
    ''' <summary>
    ''' Checks if we have selected a new Building to place!
    ''' </summary>
    ''' <param name="p"></param>
    ''' <param name="Karteneditor"></param>
    ''' <param name="Gefunden"></param>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Public Function CheckGebaeudeAuswahl(ByVal p As Point, ByVal Karteneditor As ObjektKarteneditormenue, Optional ByVal Gefunden As Boolean = True) As Boolean
        'Wir ueberpruefen ob man auf einen Pfeil geklickt hat
        Dim Startrechteck As Rectangle
        If Hauptmenue.ZoomedIn Then
            Startrechteck = New Rectangle(RechteckEditor(3).X + 3, RechteckEditor(3).Y + Pfeilplatzgesamt / 2 + 1 + Hauptmenue.Feldbreite, Hauptmenue.Feldbreite * 1.5# - 2, Hauptmenue.Feldbreite * 2 - 2)
        Else
            Startrechteck = New Rectangle(RechteckEditor(3).X + 4, RechteckEditor(3).Y + Pfeilplatzgesamt / 2 + 4, Hauptmenue.Feldbreite * 1.75#, Hauptmenue.Feldbreite * 2.75#)
        End If
        Dim Rest As Integer
        Math.DivRem((RechteckEditor(3).Height - Pfeilplatzgesamt), PlatzeinesButtons, Rest)
        Startrechteck.Y += Rest / 2
        Math.DivRem(RechteckEditor(3).Width, PlatzeinesButtons, Rest)
        Dim X2 As Integer = Rest / 2
        Startrechteck.X += Rest / 2
        Dim LuftStart As Integer = 0
        If Objektverwalter.Spielfeld.MomentaneSchlacht = ObjektSpielfeld.Luftschlacht Then LuftStart = Objektverwalter.GebaeudeTextur.GetGebaeudeZahl(MomenentanerSpieler) - LuftGebaeude
        Dim LuftEnde As Integer = Objektverwalter.AlleGebaeude.Length
        If Objektverwalter.Spielfeld.MomentaneSchlacht = ObjektSpielfeld.Bodenschlacht Then LuftEnde -= LuftGebaeude
        For I = 0 To GebaeudeinderHoehe - 1
            For I2 = 0 To GebaeudeinderBreite - 1
                If Startrechteck.Contains(p) Then
                    If Objektverwalter.GebaeudeTextur.GetGebaeudeID(I * GebaeudeinderBreite + I2 + StartIndexGebaeude + LuftStart, MomenentanerSpieler) < LuftEnde Then
                        CursorRechteck(1) = Startrechteck
                        AktuelleGebaeude = Objektverwalter.GebaeudeTextur.GetGebaeudeID(I * GebaeudeinderBreite + I2 + StartIndexGebaeude + LuftStart, MomenentanerSpieler)
                        Karteneditor.KEModus = ObjektKarteneditormenue.KEModi.Gebaeudeplazieren
                        If AktuelleGebaeude >= 0 Then
                            Gefunden = True
                        End If
                        GoTo Weiter
                    Else
                        Gefunden = False
                        GoTo Weiter
                    End If
                End If
                Startrechteck.X += Hauptmenue.Feldbreite * 1.5 + 4
            Next
            Startrechteck.Y += PlatzeinesButtons
            If Hauptmenue.ZoomedIn Then
                Startrechteck.X = RechteckEditor(3).X + 3 + X2
            Else
                Startrechteck.X = RechteckEditor(3).X + 4 + X2
            End If

        Next
Weiter:
        If Gefunden = False Then
            Startrechteck = New Rectangle(RechteckEditor(3).X + 4, RechteckEditor(3).Y + Pfeilplatzgesamt / 2 + 4, Hauptmenue.Feldbreite * 1.75#, Hauptmenue.Feldbreite * 2.75#)
            If Hauptmenue.ZoomedIn Then
                Startrechteck = New Rectangle(RechteckEditor(3).X + 3, RechteckEditor(3).Y + Pfeilplatzgesamt / 2 + 1 + Hauptmenue.Feldbreite, Hauptmenue.Feldbreite * 1.5# - 2, Hauptmenue.Feldbreite * 2 - 2)
            End If
            Math.DivRem((RechteckEditor(3).Height - Pfeilplatzgesamt), PlatzeinesButtons, Rest)
            Startrechteck.Y += Rest / 2
            Math.DivRem(RechteckEditor(3).Width, PlatzeinesButtons, Rest)
            Startrechteck.X += Rest / 2
            CursorRechteck(1) = Startrechteck
            AktuelleGebaeude = Objektverwalter.GebaeudeTextur.GetGebaeudeID(0, 0)
            Karteneditor.KEModus = ObjektKarteneditormenue.KEModi.Gebaeudeplazieren
        End If
        Return True
    End Function
    ''' <summary>
    ''' Returns over which Building the Cursor currently is.
    ''' </summary>
    ''' <param name="p"></param>
    ''' <param name="Karteneditor"></param>
    ''' <param name="Gefunden"></param>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Public Function GetGebaeudeAuswahl(ByVal p As Point, ByVal Karteneditor As ObjektKarteneditormenue, Optional ByVal Gefunden As Boolean = True) As Integer
        'Wir ueberpruefen ob man auf einen Pfeil geklickt hat
        Dim Startrechteck As Rectangle
        If Hauptmenue.ZoomedIn Then
            Startrechteck = New Rectangle(RechteckEditor(3).X + 3, RechteckEditor(3).Y + Pfeilplatzgesamt / 2 + 1 + Hauptmenue.Feldbreite, Hauptmenue.Feldbreite * 1.5# - 2, Hauptmenue.Feldbreite * 2 - 2)
        Else
            Startrechteck = New Rectangle(RechteckEditor(3).X + 4, RechteckEditor(3).Y + Pfeilplatzgesamt / 2 + 4, Hauptmenue.Feldbreite * 1.75#, Hauptmenue.Feldbreite * 2.75#)
        End If
        Dim Rest As Integer
        Math.DivRem((RechteckEditor(3).Height - Pfeilplatzgesamt), PlatzeinesButtons, Rest)
        Startrechteck.Y += Rest / 2
        Math.DivRem(RechteckEditor(3).Width, PlatzeinesButtons, Rest)
        Dim X2 As Integer = Rest / 2
        Startrechteck.X += Rest / 2
        Dim LuftStart As Integer = 0
        If Objektverwalter.Spielfeld.MomentaneSchlacht = ObjektSpielfeld.Luftschlacht Then LuftStart = Objektverwalter.GebaeudeTextur.GetGebaeudeZahl(MomenentanerSpieler) - LuftGebaeude
        Dim LuftEnde As Integer = Objektverwalter.AlleGebaeude.Length
        If Objektverwalter.Spielfeld.MomentaneSchlacht = ObjektSpielfeld.Bodenschlacht Then LuftEnde -= LuftGebaeude
        For I = 0 To GebaeudeinderHoehe - 1
            For I2 = 0 To GebaeudeinderBreite - 1
                If Startrechteck.Contains(p) Then
                    If Objektverwalter.GebaeudeTextur.GetGebaeudeID(I * GebaeudeinderBreite + I2 + StartIndexGebaeude + LuftStart, MomenentanerSpieler) < LuftEnde Then
                        Return Objektverwalter.GebaeudeTextur.GetGebaeudeID(I * GebaeudeinderBreite + I2 + StartIndexGebaeude + LuftStart, MomenentanerSpieler)
                    End If
                End If
                Startrechteck.X += Hauptmenue.Feldbreite * 1.5 + 4
            Next
            Startrechteck.Y += PlatzeinesButtons
            If Hauptmenue.ZoomedIn Then
                Startrechteck.X = RechteckEditor(3).X + 3 + X2
            Else
                Startrechteck.X = RechteckEditor(3).X + 4 + X2
            End If
        Next
        Return -1
    End Function
    ''' <summary>
    ''' Checks if we have selected a new Special Building to place!
    ''' </summary>
    ''' <param name="p"></param>
    ''' <param name="Karteneditor"></param>
    ''' <param name="Gefunden"></param>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Public Function CheckSpezialGebaeudeAuswahl(ByVal p As Point, ByVal Karteneditor As ObjektKarteneditormenue, Optional ByVal Gefunden As Boolean = False) As Boolean
        Dim Startrechteck As New Rectangle(RechteckEditor(3).X + 4, RechteckEditor(3).Y + Pfeilplatzgesamt / 2 + 4, Hauptmenue.Feldbreite * 2, Hauptmenue.Feldbreite * 2)
        If Hauptmenue.ZoomedIn Then
            Startrechteck = New Rectangle(RechteckEditor(3).X + 1, RechteckEditor(3).Y + Pfeilplatzgesamt / 2 + 1, Hauptmenue.Feldbreite * 2 - 2, Hauptmenue.Feldbreite * 2 - 2)
        End If
        Dim Rest As Integer
        Math.DivRem((RechteckEditor(3).Height - Pfeilplatzgesamt), PlatzeinesButtons, Rest)
        Startrechteck.Y += Rest / 2
        Math.DivRem(RechteckEditor(3).Width, PlatzeinesButtons, Rest)
        Dim X2 As Integer = Rest / 2
        Startrechteck.X += Rest / 2
        Dim LuftStart As Integer = 0
        If Objektverwalter.Spielfeld.MomentaneSchlacht = ObjektSpielfeld.Luftschlacht Then LuftStart = Objektverwalter.GebaeudeTextur.GetSpezialGebaeudeZahl(MomenentanerSpieler) - LuftSpezialGebaeude
        Dim LuftEnde As Integer = Objektverwalter.GebaeudeTextur.GetSpezialGebaeudeZahl(MomenentanerSpieler)
        If Objektverwalter.Spielfeld.MomentaneSchlacht = ObjektSpielfeld.Bodenschlacht Then LuftEnde -= LuftSpezialGebaeude
        For I = 0 To LandschafteninderHoehe - 1
            For I2 = 0 To LandschaftenEinheiteninderBreite - 1
                If Startrechteck.Contains(p) Then
                    If I * LandschaftenEinheiteninderBreite + I2 + StartIndexSpezialgebaeude + LuftStart < LuftEnde Then
                        CursorRechteck(1) = Startrechteck
                        AktuellesSpezialGebaeude = Objektverwalter.GebaeudeTextur.GetSpezialGebaeudeID(I * LandschaftenEinheiteninderBreite + I2 + StartIndexSpezialgebaeude + LuftStart, MomenentanerSpieler)
                        Karteneditor.KEModus = ObjektKarteneditormenue.KEModi.Spezialgebaeudeplazieren
                        If AktuellesSpezialGebaeude >= 0 Then
                            Gefunden = True
                        End If
                        GoTo Weiter
                    Else
                        Gefunden = False
                        GoTo Weiter
                    End If
                End If
                Startrechteck.X += PlatzeinesButtons
            Next
            Startrechteck.Y += PlatzeinesButtons
            Startrechteck.X = RechteckEditor(3).X + 4 + X2
        Next
Weiter:
        If Gefunden = False Then
            Startrechteck = New Rectangle(RechteckEditor(3).X + 4, RechteckEditor(3).Y + Pfeilplatzgesamt / 2 + 4, Hauptmenue.Feldbreite * 2, Hauptmenue.Feldbreite * 2)
            If Hauptmenue.ZoomedIn Then
                Startrechteck = New Rectangle(RechteckEditor(3).X + 1, RechteckEditor(3).Y + Pfeilplatzgesamt / 2 + 1, Hauptmenue.Feldbreite * 2 - 2, Hauptmenue.Feldbreite * 2 - 2)
            End If
            Math.DivRem((RechteckEditor(3).Height - Pfeilplatzgesamt), PlatzeinesButtons, Rest)
            Startrechteck.Y += Rest / 2
            Math.DivRem(RechteckEditor(3).Width, PlatzeinesButtons, Rest)
            Startrechteck.X += Rest / 2
            CursorRechteck(1) = Startrechteck
            Karteneditor.KEModus = ObjektKarteneditormenue.KEModi.Spezialgebaeudeplazieren
            AktuellesSpezialGebaeude = 0
        End If
        Return True
    End Function
    ''' <summary>
    ''' Returns over which Special Building the Cursor currently is.
    ''' </summary>
    ''' <param name="p"></param>
    ''' <param name="Karteneditor"></param>
    ''' <param name="Gefunden"></param>
    ''' <returns></returns>
    ''' <remarks></remarks>
    Public Function GetSpezialGebaeudeAuswahl(ByVal p As Point, ByVal Karteneditor As ObjektKarteneditormenue, Optional ByVal Gefunden As Boolean = False) As Integer
        Dim Startrechteck As New Rectangle(RechteckEditor(3).X + 4, RechteckEditor(3).Y + Pfeilplatzgesamt / 2 + 4, Hauptmenue.Feldbreite * 2, Hauptmenue.Feldbreite * 2)
        If Hauptmenue.ZoomedIn Then
            Startrechteck = New Rectangle(RechteckEditor(3).X + 1, RechteckEditor(3).Y + Pfeilplatzgesamt / 2 + 1, Hauptmenue.Feldbreite * 2 - 2, Hauptmenue.Feldbreite * 2 - 2)
        End If
        Dim Rest As Integer
        Math.DivRem((RechteckEditor(3).Height - Pfeilplatzgesamt), PlatzeinesButtons, Rest)
        Startrechteck.Y += Rest / 2
        Math.DivRem(RechteckEditor(3).Width, PlatzeinesButtons, Rest)
        Dim X2 As Integer = Rest / 2
        Startrechteck.X += Rest / 2
        Dim LuftStart As Integer = 0
        If Objektverwalter.Spielfeld.MomentaneSchlacht = ObjektSpielfeld.Luftschlacht Then LuftStart = Objektverwalter.GebaeudeTextur.GetSpezialGebaeudeZahl(MomenentanerSpieler) - LuftSpezialGebaeude
        Dim LuftEnde As Integer = Objektverwalter.GebaeudeTextur.GetSpezialGebaeudeZahl(MomenentanerSpieler)
        If Objektverwalter.Spielfeld.MomentaneSchlacht = ObjektSpielfeld.Bodenschlacht Then LuftEnde -= LuftSpezialGebaeude
        For I = 0 To LandschafteninderHoehe - 1
            For I2 = 0 To LandschaftenEinheiteninderBreite - 1
                If Startrechteck.Contains(p) Then
                    If I * LandschaftenEinheiteninderBreite + I2 + StartIndexSpezialgebaeude + LuftStart < LuftEnde Then
                        Return Objektverwalter.GebaeudeTextur.GetSpezialGebaeudeID(I * LandschaftenEinheiteninderBreite + I2 + StartIndexSpezialgebaeude + LuftStart, MomenentanerSpieler)
                    End If
                End If
                Startrechteck.X += PlatzeinesButtons
            Next
            Startrechteck.Y += PlatzeinesButtons
            Startrechteck.X = RechteckEditor(3).X + 4 + X2
        Next
        Return -1
    End Function

    Public Sub Spielercheck(ByVal AnzahldergemaltenSpieler As Integer)
        If MomenentanerSpieler < StartSpieler Then
            MomenentanerSpieler = StartSpieler
        ElseIf MomenentanerSpieler > StartSpieler + AnzahldergemaltenSpieler Then
            MomenentanerSpieler = StartSpieler + AnzahldergemaltenSpieler - 1
        End If
    End Sub

    Public Function CheckPfeilRunterHoch(ByVal Position As Point) As Boolean
        Dim RHoch As New Rectangle(RechteckEditor(3).X + RechteckEditor(3).Width / 2 - Hauptmenue.Feldbreite, RechteckEditor(3).Y, Hauptmenue.Feldbreite * 2, 20)
        Dim RRunter As New Rectangle(RechteckEditor(3).X + RechteckEditor(3).Width / 2 - Hauptmenue.Feldbreite, RechteckEditor(3).Y + RechteckEditor(3).Height - 20, Hauptmenue.Feldbreite * 2, 20)
        If RHoch.Contains(Position) Then
            Select Case EditorModus
                Case EditorModi.Einheiten
                    If LandschaftenEinheiteninderBreite * LandschafteninderHoehe < Objektverwalter.AlleEinheiten.Length Then
                        StartIndexEinheiten -= LandschaftenEinheiteninderBreite
                        If StartIndexEinheiten < 0 Then StartIndexEinheiten = 0
                    End If
                Case EditorModi.Gebaeude
                    If GebaeudeinderHoehe * GebaeudeinderBreite < Objektverwalter.GebaeudeTextur.GetGebaeudeZahl(MomenentanerSpieler) Then
                        StartIndexGebaeude -= GebaeudeinderBreite
                        If StartIndexGebaeude < 0 Then StartIndexGebaeude = 0
                    End If
                Case EditorModi.Spezialgebaeude
                    If LandschaftenEinheiteninderBreite * LandschafteninderHoehe < Objektverwalter.GebaeudeTextur.GetSpezialGebaeudeZahl(MomenentanerSpieler) Then
                        StartIndexSpezialgebaeude -= LandschaftenEinheiteninderBreite
                        If StartIndexSpezialgebaeude < 0 Then StartIndexSpezialgebaeude = 0
                    End If
                Case EditorModi.Landschaften
                    If LandschaftenEinheiteninderBreite * LandschafteninderHoehe < Objektverwalter.LandschaftenBilder.Length Then
                        StartIndexLandschaften -= LandschaftenEinheiteninderBreite
                        If StartIndexLandschaften < 0 Then StartIndexLandschaften = 0
                    End If
            End Select
            Return True
        ElseIf RRunter.Contains(Position) Then
            Select Case EditorModus
                Case EditorModi.Einheiten
                    If LandschaftenEinheiteninderBreite * LandschafteninderHoehe < Objektverwalter.AlleEinheiten.Length Then
                        StartIndexEinheiten += LandschaftenEinheiteninderBreite
                        Dim A As Integer = Objektverwalter.AlleEinheiten.Length - LandschaftenEinheiteninderBreite * LandschafteninderHoehe
                        If StartIndexEinheiten > A Then StartIndexEinheiten = A
                    End If
                Case EditorModi.Gebaeude
                    If GebaeudeinderHoehe * GebaeudeinderBreite < Objektverwalter.GebaeudeTextur.GetGebaeudeZahl(MomenentanerSpieler) Then
                        StartIndexGebaeude += GebaeudeinderBreite
                        Dim A As Integer = Objektverwalter.GebaeudeTextur.GetGebaeudeZahl(MomenentanerSpieler) - GebaeudeinderHoehe * GebaeudeinderBreite
                        If StartIndexGebaeude > A Then StartIndexGebaeude = A
                    End If
                Case EditorModi.Spezialgebaeude
                    If LandschaftenEinheiteninderBreite * LandschafteninderHoehe < Objektverwalter.GebaeudeTextur.GetSpezialGebaeudeZahl(MomenentanerSpieler) Then
                        StartIndexSpezialgebaeude += LandschaftenEinheiteninderBreite
                        Dim A As Integer = Objektverwalter.GebaeudeTextur.GetSpezialGebaeudeZahl(MomenentanerSpieler) - LandschaftenEinheiteninderBreite * LandschafteninderHoehe
                        If StartIndexSpezialgebaeude > A Then StartIndexSpezialgebaeude = A
                    End If
                Case EditorModi.Landschaften
                    If LandschaftenEinheiteninderBreite * LandschafteninderHoehe < Objektverwalter.LandschaftenBilder.Length Then
                        StartIndexLandschaften += LandschaftenEinheiteninderBreite
                        Dim A As Integer = Objektverwalter.LandschaftenBilder.Length - LandschaftenEinheiteninderBreite * LandschafteninderHoehe
                        If StartIndexLandschaften > A Then StartIndexLandschaften = A
                    End If
            End Select
            Return True
        Else
            Return False
        End If

    End Function
#End Region
#Region "Malen"
    Public Sub Malen()
        RandMalen()

        AuswahlButtonsMalen()

        EditorGroessenMalen()

        Spielermalen()



        Select Case EditorModus
            Case EditorModi.Einheiten
                If MomenentanerSpieler > 0 Then
                    If LandschaftenEinheiteninderBreite * LandschafteninderHoehe < Objektverwalter.AlleEinheiten.Length Then
                        PfeileMalen()
                    End If
                    EinheitenMalen()
                End If
            Case EditorModi.Landschaften
                If LandschaftenEinheiteninderBreite * LandschafteninderHoehe < Objektverwalter.LandschaftenBilder.Length Then
                    PfeileMalen()
                End If
                LandschaftenMalen()
            Case EditorModi.Gebaeude
                If GebaeudeinderHoehe * GebaeudeinderBreite < Objektverwalter.GebaeudeTextur.GetGebaeudeZahl(MomenentanerSpieler) Then
                    PfeileMalen()
                End If
                GebaeudeMalen()
            Case EditorModi.Spezialgebaeude
                If LandschaftenEinheiteninderBreite * LandschafteninderHoehe < Objektverwalter.GebaeudeTextur.GetSpezialGebaeudeZahl(MomenentanerSpieler) Then
                    PfeileMalen()
                End If
                SpezialgebaeudeMalen()
            Case ObjektKarteneditormenue.KEModi.Einheitabziehen

        End Select

        If Objektverwalter.Spielfeld.OnMap(Hauptmenue.SpielfeldPunkt) Then
            'Die Koordinaten anzeigen!
            Text.neuerText(New String() {"X: " + Hauptmenue.SpielfeldPunkt.X.ToString + "  Y: " + Hauptmenue.SpielfeldPunkt.Y.ToString}, DataSettings.BildschirmBreite - Randbreite - 100, Hauptmenue.Feldbreite / 2, New Color() {Color.FromArgb(188, 176, 136)})
            Schriftengine.DrawText(Text, New Point)
        End If

        CursorMalen()
    End Sub

    Private Sub RandMalen()
        Dim sngRotation As Double = 0
        Dim intColor As Color = Color.FromArgb(255, 255, 255, 255)
        'pruefen ob wir aus den Screenbereich laufen

        'Festlegen welchen Bereich vom Bitmap wir kopieren

        'Welcher Teil der Textur soll gemalt werden Nichts bedeutet gesamtes Bild
        If DataSettings.Verhaeltnis = Hauptmenue.Breitbild Then
            'Daten aus dem Bild 
            With Grafikengine.recBild
                .X = 0 : .Width = 200
                .Y = 0 : .Height = 151
            End With
        Else
            'Daten aus dem Bild 
            With Grafikengine.recBild
                .X = 0 : .Width = 200
                .Y = 0 : .Height = 151
            End With
        End If

        'Falls der Zoomfaktor groesser 1 ist muessen einige Raender abgeschnitten werden

        'Hier befindet sich das Rotationszentrum
        'Achtung Rotationszentrum ist auch Ausgangspunkt der bemalung
        With Grafikengine.ptfRotCenter
            .X = 0
            .Y = 0
        End With
        '... und wie breit ist es
        With Grafikengine.szfScale
            .Width = Randbreite
            .Height = 151
        End With
        Grafikengine.ptfPosition = New Drawing.Point(DataSettings.BildschirmBreite - Randbreite, 0)
        'jetzt wird es in den Backbuffer gezeichnet
        Grafikengine.Sprite.Draw2D(Rand, Grafikengine.recBild, Grafikengine.szfScale, Grafikengine.ptfRotCenter, sngRotation, Grafikengine.ptfPosition, intColor)



        If DataSettings.Verhaeltnis = Hauptmenue.Breitbild Then
            'Daten aus dem Bild 
            With Grafikengine.recBild
                .X = 0 : .Width = 200
                .Y = 152 : .Height = 648
            End With
            If DataSettings.BildschirmHoehe > 800 Then
                With Grafikengine.recBild
                    .X += 1 : .Width -= 2
                    .Y += 1 : .Height -= 2
                End With
            End If
        Else
            'Daten aus dem Bild 
            With Grafikengine.recBild
                .X = 0 : .Width = 200
                .Y = 152 : .Height = 448
            End With
            If DataSettings.BildschirmHoehe > 600 Then
                With Grafikengine.recBild
                    .X += 1 : .Width -= 2
                    .Y += 1 : .Height -= 2
                End With
            End If
        End If

        'Falls der Zoomfaktor groesser 1 ist muessen einige Raender abgeschnitten werden

        'Hier befindet sich das Rotationszentrum
        'Achtung Rotationszentrum ist auch Ausgangspunkt der bemalung
        With Grafikengine.ptfRotCenter
            .X = 0
            .Y = 0
        End With
        '... und wie breit ist es
        With Grafikengine.szfScale
            .Width = Randbreite
            .Height = DataSettings.BildschirmHoehe - 151
        End With
        Grafikengine.ptfPosition = New Drawing.Point(DataSettings.BildschirmBreite - Randbreite, 151)
        'jetzt wird es in den Backbuffer gezeichnet
        Grafikengine.Sprite.Draw2D(Rand, Grafikengine.recBild, Grafikengine.szfScale, Grafikengine.ptfRotCenter, sngRotation, Grafikengine.ptfPosition, intColor)
    End Sub

    Public Sub AuswahlButtonsMalen()
        Dim sngRotation As Double = 0
        Dim intColor As Color = Color.FromArgb(255, 255, 255, 255)
        Grafikengine.szfScale = Nothing
        Grafikengine.recBild = Nothing
        With Grafikengine.ptfRotCenter
            .X = 17
            .Y = 17
        End With
        For I = 0 To EditorModusTexturen.Length - 1
            Grafikengine.ptfPosition = New Drawing.Point(RechteckEditor(0).X + I * RechteckEditor(0).Width / EditorModusTexturen.Length + RechteckEditor(0).Width / EditorModusTexturen.Length / 2, 25)
            Grafikengine.Sprite.Draw2D(EditorModusTexturen(I), Grafikengine.recBild, Grafikengine.szfScale, Grafikengine.ptfRotCenter, sngRotation, Grafikengine.ptfPosition, intColor)
        Next

    End Sub

    Public Sub EditorGroessenMalen()
        Dim sngRotation As Double = 0
        Dim intColor As Color = Color.FromArgb(255, 255, 255, 255)
        Grafikengine.szfScale = Nothing
        Grafikengine.recBild = Nothing
        With Grafikengine.ptfRotCenter
            .X = 17
            .Y = 17
        End With
        For I = 0 To EditorModusTexturen.Length - 1
            Grafikengine.ptfPosition = New Drawing.Point(RechteckEditor(1).X + I * RechteckEditor(1).Width / EditorGroessenTexturen.Length + RechteckEditor(1).Width / EditorGroessenTexturen.Length / 2, 74)
            Grafikengine.Sprite.Draw2D(EditorGroessenTexturen(I), Grafikengine.recBild, Grafikengine.szfScale, Grafikengine.ptfRotCenter, sngRotation, Grafikengine.ptfPosition, intColor)
        Next

    End Sub

    Private Sub Spielermalen()
        If PlatzeinesSpielerButtons * Objektverwalter.Spielfeld.Spieler.Length > RechteckEditor(2).Width Then
            Dim sngRotation As Double = 0
            Dim intColor As Color = Color.FromArgb(255, 255, 255, 255)
            'Zuerst malen wir die Pfeile
            With Grafikengine.recBild
                .X = 0 : .Width = 20
                .Y = 0 : .Height = Hauptmenue.Feldbreite * 2
            End With
            With Grafikengine.szfScale
                .Width = 20
                .Height = Hauptmenue.Feldbreite * 2
            End With
            With Grafikengine.ptfRotCenter
                .X = 0
                .Y = Hauptmenue.Feldbreite
            End With
            Grafikengine.ptfPosition = New Point(RechteckEditor(2).X, RechteckEditor(2).Y + RechteckEditor(2).Height / 2)
            Grafikengine.Sprite.Draw2D(Objektverwalter.Pfeile(0), Grafikengine.recBild, Grafikengine.szfScale, Grafikengine.ptfRotCenter, sngRotation, Grafikengine.ptfPosition, intColor)
            Grafikengine.ptfPosition = New Point(RechteckEditor(2).X + RechteckEditor(2).Width - 20, RechteckEditor(2).Y + RechteckEditor(2).Height / 2)
            Grafikengine.Sprite.Draw2D(Objektverwalter.Pfeile(1), Grafikengine.recBild, Grafikengine.szfScale, Grafikengine.ptfRotCenter, sngRotation, Grafikengine.ptfPosition, intColor)
            'Und jetzt die Spieler
            Dim Rest As Integer
            Dim AnzahldergemaltenSpieler As Integer = Math.DivRem((RechteckEditor(2).Width - Pfeilplatzgesamt), PlatzeinesSpielerButtons, Rest)
            With Grafikengine.recBild
                .X = 0 : .Width = Hauptmenue.Feldbreite
                .Y = 0 : .Height = Hauptmenue.Feldbreite * 2
            End With
            With Grafikengine.ptfRotCenter
                .X = Hauptmenue.Feldbreite / 2
                .Y = Hauptmenue.Feldbreite
            End With
            '... und wie breit ist es
            With Grafikengine.szfScale
                .Width = Hauptmenue.Feldbreite * 1.5
                .Height = Hauptmenue.Feldbreite * 3
            End With
            If Hauptmenue.ZoomedIn Then
                Grafikengine.ptfPosition.Y = RechteckEditor(2).Y + RechteckEditor(2).Height / 4 - Hauptmenue.FeldbreiteKlein / 2
            Else
                Grafikengine.ptfPosition.Y = RechteckEditor(2).Y + RechteckEditor(2).Height / 4
            End If
            Grafikengine.ptfPosition.X = RechteckEditor(2).X + Pfeilplatzgesamt / 2 + Rest / 2
            For I As Integer = 0 To AnzahldergemaltenSpieler - 1
                If I + StartSpieler = 0 Then
                    Grafikengine.ptfPosition.X += Hauptmenue.Feldbreite
                    Objektverwalter.AlleGebaeude(BildIDStadtNeutral).DrawGebaeude(I + StartSpieler, "", intColor, sngRotation)
                    Grafikengine.ptfPosition.X += Hauptmenue.Feldbreite
                Else
                    Grafikengine.ptfPosition.X += Hauptmenue.Feldbreite
                    Objektverwalter.AlleGebaeude(BildIDStadt).DrawGebaeude(I + StartSpieler, "", intColor, sngRotation)
                    Grafikengine.ptfPosition.X += Hauptmenue.Feldbreite
                End If
            Next
        Else
            With Grafikengine.recBild
                .X = 0 : .Width = Hauptmenue.Feldbreite
                .Y = 0 : .Height = Hauptmenue.Feldbreite * 2
            End With
            With Grafikengine.ptfRotCenter
                .X = Hauptmenue.Feldbreite / 2
                .Y = Hauptmenue.Feldbreite
            End With
            '... und wie breit ist es
            With Grafikengine.szfScale
                .Width = Hauptmenue.Feldbreite * 1.5
                .Height = Hauptmenue.Feldbreite * 3
            End With
            If Hauptmenue.ZoomedIn Then
                Grafikengine.ptfPosition.Y = RechteckEditor(2).Y + RechteckEditor(2).Height / 4 - Hauptmenue.FeldbreiteKlein / 2
            Else
                Grafikengine.ptfPosition.Y = RechteckEditor(2).Y + RechteckEditor(2).Height / 4
            End If
            Grafikengine.ptfPosition.X = RechteckEditor(2).X + (RechteckEditor(2).Width - PlatzeinesSpielerButtons * Objektverwalter.Spielfeld.Spieler.Length) / 2
            Dim sngRotation As Double = 0
            Dim intColor As Color = Color.FromArgb(255, 255, 255, 255)
            For I As Integer = 0 To Objektverwalter.Spielfeld.Spieler.Length - 1
                If I = 0 Then
                    Grafikengine.ptfPosition.X += Hauptmenue.Feldbreite
                    Objektverwalter.AlleGebaeude(BildIDStadtNeutral).DrawGebaeude(I + StartSpieler, "", intColor, sngRotation)
                    Grafikengine.ptfPosition.X += Hauptmenue.Feldbreite
                Else
                    Grafikengine.ptfPosition.X += Hauptmenue.Feldbreite
                    Objektverwalter.AlleGebaeude(BildIDStadt).DrawGebaeude(I + StartSpieler, "", intColor, sngRotation)
                    Grafikengine.ptfPosition.X += Hauptmenue.Feldbreite
                End If
            Next
        End If
    End Sub

    Private Sub CursorMalen()
        Dim M As ObjektKarteneditormenue = Objektverwalter.Menue
        Dim sngRotation As Double = 0
        Dim intColor As Color = Color.FromArgb(255, 255, 255, 255)
        With Grafikengine.recBild
            .X = 0 : .Width = Hauptmenue.FeldbreiteKlein + 2
            .Y = 0 : .Height = Hauptmenue.FeldbreiteKlein + 2
        End With
        With Grafikengine.ptfRotCenter
            .X = 0
            .Y = 0
        End With
        For I2 = 0 To CursorRechteck.Length - 1
            With Grafikengine.szfScale
                .Width = CursorRechteck(I2).Width / 2 + 2
                .Height = CursorRechteck(I2).Height / 2 + 2
            End With
            If I2 = 1 Then
                If MomenentanerSpieler = 0 Then
                    If RechteckEditor(1).Contains(CursorRechteck(I2).X, CursorRechteck(I2).Y) Then
                        I2 += 1
                        M.KEModus = ObjektKarteneditormenue.KEModi.Nichts
                        If I2 >= CursorRechteck.Length Then
                            Exit For
                        End If
                    End If
                End If
            End If
            For I = 0 To 3
                Select Case I
                    Case 0
                        Grafikengine.ptfPosition = New Point(CursorRechteck(I2).X, CursorRechteck(I2).Y)
                    Case 1
                        Grafikengine.ptfPosition = New Point(CursorRechteck(I2).X, CursorRechteck(I2).Y + CursorRechteck(I2).Height - 18)
                    Case 2
                        Grafikengine.ptfPosition = New Point(CursorRechteck(I2).X + CursorRechteck(I2).Width - 18, CursorRechteck(I2).Y)
                    Case 3
                        Grafikengine.ptfPosition = New Point(CursorRechteck(I2).X + CursorRechteck(I2).Width - 18, CursorRechteck(I2).Y + CursorRechteck(I2).Height - 18)
                End Select
                Grafikengine.Sprite.Draw2D(TexturenHalter.GetKartenEditorCursor(I), Grafikengine.recBild, Grafikengine.szfScale, Grafikengine.ptfRotCenter, sngRotation, Grafikengine.ptfPosition, intColor)
            Next
        Next
    End Sub


    Private Sub PfeileMalen()
        Dim sngRotation As Double = 0
        Dim intColor As Color = Color.FromArgb(255, 255, 255, 255)
        With Grafikengine.recBild
            .X = 0 : .Width = Hauptmenue.Feldbreite * 2
            .Y = 0 : .Height = 20
        End With
        With Grafikengine.szfScale
            .Width = Hauptmenue.Feldbreite * 2
            .Height = 20
        End With
        With Grafikengine.ptfRotCenter
            .X = Hauptmenue.Feldbreite
            .Y = 0
        End With
        Grafikengine.ptfPosition = New Point(RechteckEditor(3).X + RechteckEditor(3).Width / 2, RechteckEditor(3).Y)
        Grafikengine.Sprite.Draw2D(Objektverwalter.Pfeile(2), Grafikengine.recBild, Grafikengine.szfScale, Grafikengine.ptfRotCenter, sngRotation, Grafikengine.ptfPosition, intColor)
        Grafikengine.ptfPosition = New Point(RechteckEditor(3).X + RechteckEditor(3).Width / 2, RechteckEditor(3).Y + RechteckEditor(3).Height - 20)
        Grafikengine.Sprite.Draw2D(Objektverwalter.Pfeile(3), Grafikengine.recBild, Grafikengine.szfScale, Grafikengine.ptfRotCenter, sngRotation, Grafikengine.ptfPosition, intColor)
    End Sub


    Private Sub EinheitenMalen()
        If Not MomenentanerSpieler = 0 Then
            Dim sngRotation As Double = 0
            Dim intColor As Color = Color.FromArgb(255, 255, 255, 255)
            With Grafikengine.recBild
                .X = 0 : .Width = Hauptmenue.Feldbreite
                .Y = 0 : .Height = Hauptmenue.Feldbreite
            End With
            With Grafikengine.szfScale
                .Width = Hauptmenue.Feldbreite * 2
                .Height = Hauptmenue.Feldbreite * 2
            End With
            With Grafikengine.ptfRotCenter
                .X = 0
                .Y = 0
            End With
            Grafikengine.ptfPosition = New Point(RechteckEditor(3).X + 4, RechteckEditor(3).Y + Pfeilplatzgesamt / 2 + 4)
            Dim Rest As Integer
            Math.DivRem((RechteckEditor(3).Height - Pfeilplatzgesamt), PlatzeinesButtons, Rest)
            Grafikengine.ptfPosition.Y += Rest / 2
            Math.DivRem(RechteckEditor(3).Width, PlatzeinesButtons, Rest)
            Dim X2 As Integer = Rest / 2
            Grafikengine.ptfPosition.X += Rest / 2

            For I = 0 To LandschafteninderHoehe - 1
                For I2 = 0 To LandschaftenEinheiteninderBreite - 1
                    If I * LandschaftenEinheiteninderBreite + I2 + StartIndexEinheiten < Objektverwalter.AlleEinheiten.Length Then
                        If DataSettings.CommanderWarsGameModus = CommanderWarsGameModi.FireEmblem Then
                            Dim FireEmblemUnit As Fire_Emblem_MOD.FEUnit = Objektverwalter.AlleEinheiten(I * LandschaftenEinheiteninderBreite + I2 + StartIndexEinheiten).Einheit

                            With Grafikengine.recBild
                                .X = 0 : .Width = FireEmblemUnit.UnitSize.Width
                                .Y = 0 : .Height = FireEmblemUnit.UnitSize.Height
                            End With
                            With Grafikengine.szfScale
                                .Width = FireEmblemUnit.UnitSize.Width * 2
                                .Height = FireEmblemUnit.UnitSize.Height * 2
                            End With
                        End If
                        ObjektEinheit.Malen(Objektverwalter.Spielfeld.Spieler(MomenentanerSpieler), 0, I * LandschaftenEinheiteninderBreite + I2 + StartIndexEinheiten, Objektverwalter.Spielfeld.Spieler(MomenentanerSpieler).Farbe)
                    Else
                        Exit Sub
                    End If
                    Grafikengine.ptfPosition.X += PlatzeinesButtons
                Next
                Grafikengine.ptfPosition.Y += PlatzeinesButtons
                Grafikengine.ptfPosition.X = RechteckEditor(3).X + 4 + X2
            Next
        End If
    End Sub
    Private Sub GebaeudeMalen()
        Dim sngRotation As Double = 0
        Dim intColor As Color = Color.FromArgb(255, 255, 255, 255)
        With Grafikengine.recBild
            .X = 0 : .Width = Hauptmenue.Feldbreite
            .Y = 0 : .Height = Hauptmenue.Feldbreite * 2
        End With
        With Grafikengine.ptfRotCenter
            .X = 0
            .Y = 0
        End With
        With Grafikengine.szfScale
            .Width = Hauptmenue.Feldbreite * 1.5
            .Height = Hauptmenue.Feldbreite * 3
        End With
        Grafikengine.ptfPosition = New Point(RechteckEditor(3).X + 4, RechteckEditor(3).Y + Pfeilplatzgesamt / 2 + 4)
        Dim Rest As Integer
        Math.DivRem((RechteckEditor(3).Height - Pfeilplatzgesamt), PlatzeinesButtons, Rest)
        Grafikengine.ptfPosition.Y += Rest / 2
        Math.DivRem(RechteckEditor(3).Width, PlatzeinesButtons, Rest)
        Dim X2 As Integer = Rest / 2
        Grafikengine.ptfPosition.X += Rest / 2
        Dim LuftStart As Integer = 0
        If Objektverwalter.Spielfeld.MomentaneSchlacht = ObjektSpielfeld.Luftschlacht Then LuftStart = Objektverwalter.GebaeudeTextur.GetGebaeudeZahl(MomenentanerSpieler) - LuftGebaeude
        Dim LuftEnde As Integer = Objektverwalter.AlleGebaeude.Length
        If Objektverwalter.Spielfeld.MomentaneSchlacht = ObjektSpielfeld.Bodenschlacht Then LuftEnde -= LuftGebaeude

        For I = 0 To GebaeudeinderHoehe - 1
            For I2 = 0 To GebaeudeinderBreite - 1
                If Objektverwalter.GebaeudeTextur.GetGebaeudeID(I * GebaeudeinderBreite + I2 + StartIndexGebaeude + LuftStart, MomenentanerSpieler) < LuftEnde Then
                    Objektverwalter.GebaeudeTextur.DrawGebaeude(I * GebaeudeinderBreite + I2 + StartIndexGebaeude + LuftStart, MomenentanerSpieler, Objektverwalter.Spielfeld.Spieler(MomenentanerSpieler).Armee, intColor, sngRotation)
                Else
                    Exit Sub
                End If
                Grafikengine.ptfPosition.X += Hauptmenue.Feldbreite * 1.5 + 4
            Next
            Grafikengine.ptfPosition.Y += PlatzeinesButtons
            Grafikengine.ptfPosition.X = RechteckEditor(3).X + 4 + X2
        Next
    End Sub
    Private Sub SpezialgebaeudeMalen()
        Dim sngRotation As Double = 0
        Dim intColor As Color = Color.FromArgb(255, 255, 255, 255)
        With Grafikengine.recBild
            .X = 0 : .Width = Hauptmenue.Feldbreite
            .Y = 0 : .Height = Hauptmenue.Feldbreite
        End With
        With Grafikengine.szfScale
            .Width = Hauptmenue.Feldbreite * 2
            .Height = Hauptmenue.Feldbreite * 2
        End With
        With Grafikengine.ptfRotCenter
            .X = 0
            .Y = 0
        End With
        Grafikengine.ptfPosition = New Point(RechteckEditor(3).X + 4, RechteckEditor(3).Y + Pfeilplatzgesamt / 2 + 4)
        Dim Rest As Integer
        Math.DivRem((RechteckEditor(3).Height - Pfeilplatzgesamt), PlatzeinesButtons, Rest)
        Grafikengine.ptfPosition.Y += Rest / 2
        Math.DivRem(RechteckEditor(3).Width, PlatzeinesButtons, Rest)
        Dim X2 As Integer = Rest / 2
        Grafikengine.ptfPosition.X += Rest / 2
        Dim LuftStart As Integer = 0
        If Objektverwalter.Spielfeld.MomentaneSchlacht = ObjektSpielfeld.Luftschlacht Then LuftStart = Objektverwalter.GebaeudeTextur.GetSpezialGebaeudeZahl(MomenentanerSpieler) - LuftSpezialGebaeude
        Dim LuftEnde As Integer = Objektverwalter.GebaeudeTextur.GetSpezialGebaeudeZahl(MomenentanerSpieler)
        If Objektverwalter.Spielfeld.MomentaneSchlacht = ObjektSpielfeld.Bodenschlacht Then LuftEnde -= LuftSpezialGebaeude
        For I = 0 To LandschafteninderHoehe - 1
            For I2 = 0 To LandschaftenEinheiteninderBreite - 1
                If I * LandschaftenEinheiteninderBreite + I2 + StartIndexSpezialgebaeude + LuftStart < LuftEnde Then
                    Objektverwalter.GebaeudeTextur.DrawSpezialGebaeudeSymbol(I * LandschaftenEinheiteninderBreite + I2 + StartIndexSpezialgebaeude + LuftStart, MomenentanerSpieler, Objektverwalter.Spielfeld.Spieler(MomenentanerSpieler).Armee, intColor, sngRotation)
                Else
                    Exit Sub
                End If
                Grafikengine.ptfPosition.X += PlatzeinesButtons
            Next
            Grafikengine.ptfPosition.Y += PlatzeinesButtons
            Grafikengine.ptfPosition.X = RechteckEditor(3).X + 4 + X2
        Next
    End Sub
    Private Sub LandschaftenMalen()
        Dim sngRotation As Double = 0
        Dim intColor As Color = Color.FromArgb(255, 255, 255, 255)
        With Grafikengine.recBild
            .X = 0 : .Width = Hauptmenue.Feldbreite
            .Y = 0 : .Height = Hauptmenue.Feldbreite
        End With
        With Grafikengine.szfScale
            .Width = Hauptmenue.Feldbreite * 2
            .Height = Hauptmenue.Feldbreite * 2
        End With
        With Grafikengine.ptfRotCenter
            .X = 0
            .Y = 0
        End With
        Grafikengine.ptfPosition = New Point(RechteckEditor(3).X + 4, RechteckEditor(3).Y + Pfeilplatzgesamt / 2 + 4)
        Dim Rest As Integer
        Math.DivRem((RechteckEditor(3).Height - Pfeilplatzgesamt), PlatzeinesButtons, Rest)
        Grafikengine.ptfPosition.Y += Rest / 2
        Math.DivRem(RechteckEditor(3).Width, PlatzeinesButtons, Rest)
        Dim X2 As Integer = Rest / 2
        Grafikengine.ptfPosition.X += Rest / 2
        Dim LuftStart As Integer = 0
        If Objektverwalter.Spielfeld.MomentaneSchlacht = ObjektSpielfeld.Luftschlacht Then LuftStart = Objektverwalter.LandschaftenBilder.Length - LuftLandschaften
        Dim LuftEnde As Integer = Objektverwalter.LandschaftenBilder.Length
        If Objektverwalter.Spielfeld.MomentaneSchlacht = ObjektSpielfeld.Bodenschlacht Then LuftEnde -= LuftLandschaften
        For I = 0 To LandschafteninderHoehe - 1
            For I2 = 0 To LandschaftenEinheiteninderBreite - 1
                If I * LandschaftenEinheiteninderBreite + I2 + StartIndexLandschaften + LuftStart < LuftEnde Then
                    If Objektverwalter.LandschaftenBilder(I * LandschaftenEinheiteninderBreite + I2 + StartIndexLandschaften + LuftStart).Gross = False Then
                        With Grafikengine.recBild
                            .X = 0 : .Width = Hauptmenue.Feldbreite
                            .Y = 0 : .Height = Hauptmenue.Feldbreite
                        End With
                        With Grafikengine.szfScale
                            .Width = Hauptmenue.Feldbreite * 2
                            .Height = Hauptmenue.Feldbreite * 2
                        End With
                        With Grafikengine.ptfRotCenter
                            .X = 0
                            .Y = 0
                        End With
                        Dim Underground() As String = Objektverwalter.LandschaftenBilder(I * LandschaftenEinheiteninderBreite + I2 + StartIndexLandschaften + LuftStart).GetTerrainUntergrund
                        Dim ID As Integer = -1
                        Dim ID2 As Integer = -1
                        If Underground.Length > 0 Then
                            ID = ObjektLandschaftsTextur.GetID(Underground(0))
                            Underground = Objektverwalter.LandschaftenBilder(ID).GetTerrainUntergrund
                            If Underground.Length > 0 Then
                                ID2 = ObjektLandschaftsTextur.GetID(Underground(0))
                            End If
                        End If
                        If Objektverwalter.LandschaftenBilder(I * LandschaftenEinheiteninderBreite + I2 + StartIndexLandschaften + LuftStart).DrawSpecialStyle(0, 0, 255, Grafikengine.ptfPosition.X, Grafikengine.ptfPosition.Y, ID, 0, ID2, 0, True) = False Then
                            Grafikengine.Sprite.Draw2D(Objektverwalter.LandschaftenBilder(I * LandschaftenEinheiteninderBreite + I2 + StartIndexLandschaften + LuftStart).Texturen(0), Grafikengine.recBild, Grafikengine.szfScale, Grafikengine.ptfRotCenter, sngRotation, Grafikengine.ptfPosition, intColor)
                        End If
                    Else
                        With Grafikengine.recBild
                            .X = 0 : .Width = Hauptmenue.Feldbreite
                            .Y = 0 : .Height = Hauptmenue.Feldbreite * 2
                        End With
                        With Grafikengine.szfScale
                            .Width = Hauptmenue.Feldbreite * 2
                            .Height = Hauptmenue.Feldbreite * 4
                        End With
                        With Grafikengine.ptfRotCenter
                            .X = 0
                            .Y = Hauptmenue.Feldbreite
                        End With
                        Dim Underground() As String = Objektverwalter.LandschaftenBilder(I * LandschaftenEinheiteninderBreite + I2 + StartIndexLandschaften + LuftStart).GetTerrainUntergrund
                        Dim ID As Integer = -1
                        Dim ID2 As Integer = -1
                        If Underground.Length > 0 Then
                            ID = ObjektLandschaftsTextur.GetID(Underground(0))
                            Underground = Objektverwalter.LandschaftenBilder(ID).GetTerrainUntergrund
                            If Underground.Length > 0 Then
                                ID2 = ObjektLandschaftsTextur.GetID(Underground(0))
                            End If
                        End If
                        If Objektverwalter.LandschaftenBilder(I * LandschaftenEinheiteninderBreite + I2 + StartIndexLandschaften + LuftStart).DrawSpecialStyle(0, 0, 255, Grafikengine.ptfPosition.X, Grafikengine.ptfPosition.Y, ID, 0, ID2, 0, True) = False Then
                            Grafikengine.Sprite.Draw2D(Objektverwalter.LandschaftenBilder(I * LandschaftenEinheiteninderBreite + I2 + StartIndexLandschaften + LuftStart).Texturen(0), Grafikengine.recBild, Grafikengine.szfScale, Grafikengine.ptfRotCenter, sngRotation, Grafikengine.ptfPosition, intColor)
                        End If
                    End If
                Else
                    Exit Sub
                End If
                Grafikengine.ptfPosition.X += PlatzeinesButtons
            Next
            Grafikengine.ptfPosition.Y += PlatzeinesButtons
            Grafikengine.ptfPosition.X = RechteckEditor(3).X + 4 + X2
        Next
    End Sub
#End Region
    Public Sub ChangeWindowSize(ByVal PosChange)
        If DataSettings.Verhaeltnis = Hauptmenue.Breitbild Then
            Rand = Grafikengine.LoadTexture(DataSettings.Resourcenpfad + "Editor\Rand+1.6.bmp")
            'Zahlenwerte sind Daten aus dem Bild 
            Randbreite = 200 * DataSettings.Streckfaktor
            Hauptmenue.Rechteck.Width = DataSettings.BildschirmBreite - Randbreite
            RechteckEditor(0) = New Rectangle(DataSettings.BildschirmBreite - Randbreite + 7 * DataSettings.Streckfaktor, 7, 188 * DataSettings.Streckfaktor, 38)
            RechteckEditor(1) = New Rectangle(DataSettings.BildschirmBreite - Randbreite + 7 * DataSettings.Streckfaktor, 57, 188 * DataSettings.Streckfaktor, 38)
            RechteckEditor(2) = New Rectangle(DataSettings.BildschirmBreite - Randbreite + 7 * DataSettings.Streckfaktor, 106, 188 * DataSettings.Streckfaktor, 38)
            RechteckEditor(3) = New Rectangle(DataSettings.BildschirmBreite - Randbreite + 7 * DataSettings.Streckfaktor, 151 + 3 * ((DataSettings.BildschirmHoehe - 151) / 649), 188 * DataSettings.Streckfaktor, 637 * ((DataSettings.BildschirmHoehe - 151) / 649))

        Else
            Rand = Grafikengine.LoadTexture(DataSettings.Resourcenpfad + "Editor\Rand+1.3.bmp")
            'Zahlenwerte sind Daten aus dem Bild 
            Randbreite = 200 * DataSettings.Streckfaktor
            Hauptmenue.Rechteck.Width = DataSettings.BildschirmBreite - Randbreite
            RechteckEditor(0) = New Rectangle(DataSettings.BildschirmBreite - Randbreite + 7 * DataSettings.Streckfaktor, 7, 188 * DataSettings.Streckfaktor, 38)
            RechteckEditor(1) = New Rectangle(DataSettings.BildschirmBreite - Randbreite + 7 * DataSettings.Streckfaktor, 57, 188 * DataSettings.Streckfaktor, 38)
            RechteckEditor(2) = New Rectangle(DataSettings.BildschirmBreite - Randbreite + 7 * DataSettings.Streckfaktor, 106, 188 * DataSettings.Streckfaktor, 38)
            RechteckEditor(3) = New Rectangle(DataSettings.BildschirmBreite - Randbreite + 7 * DataSettings.Streckfaktor, 151 + 3 * ((DataSettings.BildschirmHoehe - 151) / 449), 188 * DataSettings.Streckfaktor, 437 * ((DataSettings.BildschirmHoehe - 151) / 449))

        End If
        'Hier wird festgelegt wie viele Bilder im Editor bereich angezeigt werden
        Dim Rest As Integer

        LandschaftenEinheiteninderBreite = Math.DivRem(RechteckEditor(3).Width, PlatzeinesButtons, Rest)
        LandschafteninderHoehe = Math.DivRem((RechteckEditor(3).Height - Pfeilplatzgesamt), PlatzeinesButtons, Rest)
        GebaeudeinderHoehe = Math.DivRem((RechteckEditor(3).Height - Pfeilplatzgesamt), PlatzeinesButtons, Rest)
        GebaeudeinderBreite = Math.DivRem(RechteckEditor(3).Width, Hauptmenue.Feldbreite * 2, Rest)
        StartSpieler = 0
        'Jetzt Cursor
        CursorRechteckesetzen()
    End Sub
    Public Sub Reset()
        Rand.Dispose()
        Rand = Nothing
        For i = 0 To EditorModusTexturen.Length - 1
            EditorModusTexturen(i).Dispose()
            EditorModusTexturen(i) = Nothing
        Next
        For i = 0 To EditorGroessenTexturen.Length - 1
            EditorGroessenTexturen(i).Dispose()
            EditorGroessenTexturen(i) = Nothing
        Next
        Grafikengine.Grafikkarte.EvictManagedResources()
    End Sub
End Class
